home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1994 / MacHack 1994.toast / MacHack™94 / Miscellaneous / DropShell 2.0 sources / DSUtils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-01  |  11.1 KB  |  390 lines  |  [TEXT/R*ch]
  1. /******************************************************************************
  2. **
  3. **  Project Name:    DropShell
  4. **     File Name:    DSUtils.c
  5. **
  6. **   Description:    Utility routines that may be useful to DropBoxes
  7. **
  8. *******************************************************************************
  9. **                       A U T H O R   I D E N T I T Y
  10. *******************************************************************************
  11. **
  12. **    Initials    Name
  13. **    --------    -----------------------------------------------
  14. **    SCS            Stephan Somogyi
  15. **    LDR            Leonard Rosenthol
  16. **
  17. *******************************************************************************
  18. **                      R E V I S I O N   H I S T O R Y
  19. *******************************************************************************
  20. **
  21. **      Date        Author    Description
  22. **    ---------    ------    ---------------------------------------------
  23. **    23 Jun 94    LDR        Added a bunch of new routines for Marshall
  24. **    20 Feb 94    LDR        Added some new useful File System routines
  25. **    11 Dec 93    SCS        Universal Headers/UPPs (Phoenix 68k/PPC & PPCC)
  26. **                        Skipped System 6 compatible rev of DropShell source
  27. **                        Changed GetAppName to GetMyAppName (StdCLib conflict)
  28. **    12/09/91    LDR        Added the Apple event routines
  29. **    11/24/91    LDR        Original Version
  30. **
  31. ******************************************************************************/
  32.  
  33. #include <Dialogs.h>
  34. #include <Types.h>
  35.  
  36. #include "DSGlobals.h"
  37. #include "DSUtils.h"
  38.  
  39. /*
  40.     This routine is used to properly center an Alert before showing.
  41.     
  42.     It is per Human Interface specs by putting it in the top 1/3 of screen.
  43.     NOTE: This same technique can be used with DLOG resources as well.
  44. */
  45. #pragma segment Main
  46. void CenterAlert ( short theID ) {
  47.     short        theX, theY;
  48.     AlertTHndl    theAlertHandle;
  49.     Rect        screen, alrt;
  50.     
  51.     theAlertHandle = (AlertTHndl) GetResource ( 'ALRT', theID );
  52.     if ( theAlertHandle != NULL ) {
  53.         HLock ((Handle) theAlertHandle );
  54.  
  55.         alrt = (*theAlertHandle)->boundsRect;
  56.         screen = qd.screenBits.bounds;
  57.         
  58.         theX = (( screen.right - screen.left ) - (alrt.right - alrt.left )) >> 1;
  59.         theY = (( screen.bottom - screen.top ) + GetMBarHeight () - (alrt.bottom - alrt.top)) >> 1;
  60.         theY -= ( screen.bottom - screen.top ) >> 2;    /* this moves it up for better viewing! */
  61.         OffsetRect ( &(*theAlertHandle)->boundsRect, theX - alrt.left, theY - alrt.top );
  62.     }
  63.         
  64.     SetCursor ( &qd.arrow );    // change this for code resources!
  65. }
  66.  
  67. /*
  68.     This routine is just a quick & dirty error reporter
  69. */
  70. #pragma segment Main
  71. void ErrorAlert ( short stringListID, short stringIndexID, short errorID ) {
  72.     #define    kAlertID    200
  73.     Str255    param, errorStr;
  74.  
  75.     NumToString ( errorID, errorStr );
  76.     GetIndString ( param, stringListID, stringIndexID );
  77.     ParamText ( param,  errorStr, NULL, NULL );
  78.     CenterAlert ( kAlertID );
  79.     (void) Alert ( kAlertID, NULL );
  80. }
  81.  
  82. /*** These routines use the Process Manager to give you information about yourself ***/
  83.  
  84. #pragma segment Main
  85. void GetMyAppName(Str255 appName)    {
  86.     OSErr                err;
  87.     ProcessInfoRec        info;
  88.     ProcessSerialNumber    curPSN;
  89.  
  90.     err = GetCurrentProcess(&curPSN);
  91.     
  92.     info.processInfoLength = sizeof(ProcessInfoRec);    // ALWAYS USE sizeof!
  93.     info.processName = appName;                            // so it returned somewhere
  94.     info.processAppSpec = NULL;                            // I don't care!
  95.  
  96.     err = GetProcessInformation(&curPSN, &info);
  97. }
  98.  
  99. #pragma segment Main
  100. void GetAppFSSpec(FSSpec *appSpec)    {
  101.     OSErr                err;
  102.     Str255                appName;
  103.     ProcessInfoRec        info;
  104.     ProcessSerialNumber    curPSN;
  105.  
  106.     err = GetCurrentProcess(&curPSN);
  107.     
  108.     info.processInfoLength = sizeof(ProcessInfoRec);    // ALWAYS USE sizeof!
  109.     info.processName = appName;                            // so it returned somewhere
  110.     info.processAppSpec = appSpec;                        // so it can get returned!
  111.  
  112.     err = GetProcessInformation(&curPSN, &info);
  113. }
  114.  
  115. /* ••• File Routines begin here ••• */
  116. /*
  117.     This routine is used to force the Finder (as much as is possible) to update
  118.     information about a newly changed file or folder.  
  119.     It does this by changing the modification date of the surrounding folder.
  120. */
  121. OSErr ForceFinderUpdate(FSSpec *pFSS, Boolean flush)
  122. {
  123.     OSErr            lErr;
  124.     CInfoPBRec        lCBlk;
  125.     
  126.     if (pFSS->parID != 1)                            // if it's a vol then reuse the NameStr
  127.         lCBlk.dirInfo.ioNamePtr = 0L;
  128.     lCBlk.dirInfo.ioVRefNum = pFSS->vRefNum;        
  129.     lCBlk.dirInfo.ioDrDirID = pFSS->parID;
  130.     lCBlk.dirInfo.ioFDirIndex = 0;
  131.     lCBlk.dirInfo.ioCompletion = 0;
  132.  
  133.     lErr = PBGetCatInfoSync(&lCBlk);
  134.     if (!lErr) {
  135.         GetDateTime(&lCBlk.dirInfo.ioDrMdDat);
  136.         lCBlk.dirInfo.ioDrDirID = pFSS->parID;
  137.         lErr = PBSetCatInfoSync(&lCBlk);
  138.     
  139.         if ((!lErr) && (flush))
  140.             lErr = FlushVol(nil, pFSS->vRefNum);
  141.     }
  142.     
  143.     return (lErr);
  144. }
  145.  
  146. /*    Is the file in use (busy)? */
  147. Boolean FSpIsBusy(FSSpecPtr theFile)
  148. {
  149.     Boolean        isBusy = false;
  150.     OSErr        err;
  151.     CInfoPBRec    cipb;
  152.     
  153.     cipb.hFileInfo.ioCompletion    = 0L;
  154.     cipb.hFileInfo.ioNamePtr    = theFile->name;
  155.     cipb.hFileInfo.ioVRefNum    = theFile->vRefNum;
  156.     cipb.hFileInfo.ioFDirIndex    = 0;
  157.     cipb.hFileInfo.ioDirID        = theFile->parID;
  158.     err = PBGetCatInfoSync(&cipb);
  159.     if (!err) {
  160.         isBusy = (cipb.hFileInfo.ioFlAttrib & 0x80) == 0x80;    // bit 7 = either fork open
  161.     }
  162.     return(isBusy);
  163. }
  164.  
  165. /*    Is the “file” represented by this FSSpec really a folder? */
  166. Boolean    FSpIsFolder (FSSpecPtr theFSSpec) 
  167. {
  168.     OSErr    err;
  169.     CInfoPBRec    pb;
  170.     Str255    fName;
  171.     
  172.     if (theFSSpec->parID == fsRtParID)    // it's a volume!!
  173.         return(true);
  174.         
  175.     BlockMoveData (theFSSpec->name, fName, 32);
  176.     pb.hFileInfo.ioDirID        = theFSSpec->parID;
  177.     pb.hFileInfo.ioCompletion    = NULL;
  178.     pb.hFileInfo.ioNamePtr        = fName;
  179.     pb.hFileInfo.ioVRefNum        = theFSSpec->vRefNum;
  180.     pb.hFileInfo.ioFDirIndex    = 0;
  181.     pb.hFileInfo.ioFVersNum        = 0;
  182.     err = PBGetCatInfoSync(&pb);
  183.     
  184.     if (!err) {
  185.         if (pb.hFileInfo.ioFlAttrib & ioDirMask)
  186.             return(true);
  187.     }
  188.     return(false);
  189. }
  190.  
  191. // Creates an empty handle to which FSSpecs could be added later!
  192. FSSpecArrayHandle    NewFSSpecList(void)
  193. {
  194.     return((FSSpecArrayHandle)NewHandle(0));
  195. }
  196.  
  197. // Releases memory used by an FSSpecList when all done
  198. void DisposeFSSpecList(FSSpecArrayHandle fsList)
  199. {
  200.     DisposHandle((Handle)fsList);
  201. }
  202.  
  203. // Adds the new FSSpec to the end of an FSSpecList
  204. void AddToFSSpecList(FSSpec *fSpec, FSSpecArrayHandle fileList)
  205. {
  206.     Size    curSize, newSize;
  207.     long    numFiles;
  208.  
  209.     if ((!fileList) || (!fSpec)) return;    // if either is bogus, get out fast
  210.     
  211.     curSize = GetHandleSize((Handle)fileList);
  212.     numFiles = curSize / sizeof(FSSpec);
  213.     newSize = curSize + sizeof(FSSpec);
  214.     SetHandleSize((Handle)fileList, newSize);
  215.     if (MemError())    return;        // any problems, get out
  216.     
  217.     BlockMove(fSpec, &(*fileList)[numFiles], sizeof(FSSpec));
  218. }
  219.  
  220.  
  221. /* ••• Apple event routines begin here ••• */
  222.  
  223. /*
  224.     This routine will create a targetDesc for sending to self.
  225.  
  226.     We take IM VI's advice and use the typePSN form with 
  227.     kCurrentProcess as the targetPSN.
  228. */
  229. OSErr GetTargetFromSelf (AEAddressDesc *targetDesc)
  230. {
  231.     ProcessSerialNumber    psn;
  232.  
  233.     psn.highLongOfPSN     = 0;
  234.     psn.lowLongOfPSN     = kCurrentProcess;
  235.  
  236.     return( AECreateDesc(typeProcessSerialNumber, (Ptr)&psn, sizeof(ProcessSerialNumber), targetDesc) );
  237. }
  238.  
  239. /* This routine will create a targetDesc using the apps signature */
  240. OSErr GetTargetFromSignature (OSType processSig, AEAddressDesc *targetDesc)
  241. {
  242.     return( AECreateDesc(typeApplSignature, (Ptr)&processSig, sizeof(processSig), targetDesc) );
  243. }
  244.  
  245. /* This routine will create a targetDesc by bringing up the PPCBrowser */
  246. OSErr GetTargetFromBrowser(Str255 promptStr, AEAddressDesc *targetDesc)
  247. {
  248.     OSErr        err;
  249.     TargetID    theTarget;
  250.     PortInfoRec    portInfo;
  251.     
  252.     err = PPCBrowser(promptStr, "\p", false, &theTarget.location, &portInfo, NULL, "\p");
  253.     if (err == noErr) {
  254.         theTarget.name = portInfo.name;
  255.         err = AECreateDesc(typeTargetID, (Ptr)&theTarget, sizeof(TargetID), targetDesc);
  256.     }
  257.     return( err );
  258. }
  259.  
  260.  
  261. /*
  262.     This routine is the low level routine used by the SendODOCToSelf
  263.     routine.  It gets passed the list of files (in an AEDescList)
  264.     to be sent as the data for the 'odoc', builds up the event
  265.     and sends off the event.  
  266.  
  267.     It is broken out from SendODOCToSelf so that a SendODOCListToSelf could
  268.     easily be written and it could then call this routine - but that is left
  269.     as an exercise to the reader.
  270.     
  271.     Read the comments in the code for the order and details
  272. */
  273. void _SendDocsToSelf (AEDescList *aliasList)
  274. {
  275.     OSErr            err;
  276.     AEAddressDesc    theTarget;
  277.     AppleEvent        openDocAE, replyAE;
  278.  
  279. /*
  280.     First we create the target for the event.   We call another
  281.     utility routine for creating the target.
  282. */
  283.     err = GetTargetFromSelf(&theTarget);
  284.     if (err == noErr) {
  285.         /* Next we create the Apple event that will later get sent. */
  286.         err = AECreateAppleEvent(kCoreEventClass, kAEOpenDocuments, &theTarget, kAutoGenerateReturnID, kAnyTransactionID, &openDocAE);
  287.  
  288.         if (err == noErr) {
  289.             /* Now add the aliasDescList to the openDocAE */
  290.             err = AEPutParamDesc(&openDocAE, keyDirectObject, aliasList);
  291.  
  292.             if (err == noErr) {
  293.                 /*
  294.                     and finally send the event
  295.                     Since we are sending to ourselves, no need for reply.
  296.                 */
  297.                 err = AESend(&openDocAE, &replyAE, kAENoReply + kAECanInteract, kAENormalPriority, 3600, NULL, NULL);
  298.  
  299.                 /*
  300.                     NOTE: Since we are not requesting a reply, we do not need to
  301.                     need to dispose of the replyAE.  It is there simply as a 
  302.                     placeholder.
  303.                 */
  304.             }
  305.  
  306.         /*    
  307.             Dispose of the aliasList descriptor
  308.             We do this instead of the caller since it needs to be done
  309.             before disposing the AEVT
  310.         */
  311.             err = AEDisposeDesc(aliasList);
  312.         }
  313.  
  314.     /*and of course dispose of the openDoc AEVT itself*/
  315.         err = AEDisposeDesc(&openDocAE);
  316.     }
  317. }
  318.  
  319. /*
  320.     This is the routine called by SelectFile to send a single odoc to ourselves.
  321.     
  322.     It calls the above low level routine to do the dirty work of sending the AEVT -
  323.     all we do here is build a AEDescList of the file to be opened.
  324. */
  325. void SendODOCToSelf (FSSpec *theFileSpec) {
  326.  
  327.     OSErr        err;
  328.     AEDescList    aliasList;
  329.     AEDesc        aliasDesc;
  330.     AliasHandle    aliasH;
  331.     
  332.     /*Create the descList to hold the list of files*/
  333.     err = AECreateList(NULL, 0, false, &aliasList);
  334.  
  335.     if (err == noErr) {
  336.         /* First we setup the type of descriptor */
  337.         aliasDesc.descriptorType = typeAlias;
  338.  
  339.         /*
  340.             Now we add the file to descList by creating an alias and then
  341.             adding it into the descList using AEPutDesc
  342.         */
  343.         err = NewAlias(NULL, theFileSpec, &aliasH);
  344.         aliasDesc.dataHandle = (Handle)aliasH;
  345.         err = AEPutDesc(&aliasList, 0, &aliasDesc);
  346.         DisposHandle((Handle)aliasH);
  347.  
  348.         /*Now call the real gut level routine to do the dirty work*/
  349.         _SendDocsToSelf(&aliasList);
  350.  
  351.         /*_SendDocsToSelf will dispose of aliasList for me*/
  352.     }
  353. }
  354.  
  355.  
  356. void SendQuitToSelf (void)
  357. {
  358.     OSErr            err;
  359.     AEAddressDesc    theTarget;
  360.     AppleEvent        quitAE, replyAE;
  361.  
  362. /*
  363.     First we create the target for the event.   We call another
  364.     utility routine for creating the target.
  365. */
  366.     err = GetTargetFromSelf(&theTarget);
  367.     if (err == noErr) {
  368.         /* Next we create the Apple event that will later get sent. */
  369.         err = AECreateAppleEvent(kCoreEventClass, kAEQuitApplication, &theTarget, kAutoGenerateReturnID, kAnyTransactionID, &quitAE);
  370.  
  371.         if (err == noErr) {
  372.             /*
  373.                 and finally send the event
  374.                 Since we are sending to ourselves, no need for reply.
  375.             */
  376.             err = AESend(&quitAE, &replyAE, kAENoReply + kAECanInteract, kAENormalPriority, 3600, NULL, NULL);
  377.  
  378.             /*
  379.                 NOTE: Since we are not requesting a reply, we do not need to
  380.                 need to dispose of the replyAE.  It is there simply as a 
  381.                 placeholder.
  382.             */
  383.         }
  384.  
  385.         /* and of course dispose of the quit AEVT itself */
  386.         err = AEDisposeDesc(&quitAE);
  387.     }
  388. }
  389.  
  390.